home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #1 / Amiga Plus CD - 2000 - No. 1.iso / Tools / Dev / mamesrc / src / amiga / mainppc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-03  |  9.7 KB  |  398 lines
  1. /**************************************************************************
  2.  *
  3.  * Copyright (C) 1999 Mats Eirik Hansen (mats.hansen@triumph.no)
  4.  *
  5.  * $Id: mainppc.c,v 1.1 1999/04/28 18:54:28 meh Exp meh $
  6.  *
  7.  * $Log: mainppc.c,v $
  8.  * Revision 1.1  1999/04/28 18:54:28  meh
  9.  * Initial revision
  10.  *
  11.  *
  12.  *************************************************************************/
  13.  
  14. #include <stdio.h>
  15.  
  16. #include <exec/nodes.h>
  17. #include <exec/lists.h>
  18. #include <exec/memory.h>
  19. #include <utility/tagitem.h>
  20. #include <powerup/ppclib/interface.h>
  21. #include <powerup/ppclib/message.h>
  22. #include <powerup/ppclib/tasks.h>
  23. #include <powerup/gcclib/powerup_protos.h>
  24.  
  25. #include "main.h"
  26. #include "version.h"
  27. #include "config.h"
  28. #include "file.h"
  29. #include "audio.h"
  30. #include "osdepend.h"
  31. #include "driver.h"
  32.  
  33. void  *M68kPort;
  34. void  *PPCPort;
  35. void  *MyMsg;
  36. LONG  *MsgData;
  37.  
  38. LONG  Config[CFG_ITEMS];
  39.  
  40. extern struct osd_bitmap *BitMap;
  41. extern LONG              ClearBitMap;
  42. extern int               frameskip;
  43. extern int               throttle;
  44. extern char              *DirtyLines;
  45.  
  46. LONG FPS;
  47. LONG FrameSkip;
  48.  
  49. LONG                  Width;
  50. LONG                  Height;
  51. struct Audio          *Audio;
  52. struct Video          *Video;
  53. struct AChannelArray  *ChannelArray[2];
  54. struct VPixelArray    *PixelArray[2];
  55. struct VDirectArray   *DirectArray;
  56. LONG                  ChannelArraySize;
  57. LONG                  CurrentArray;
  58. BYTE                  *Keys;
  59. struct IPort          *Port1;
  60. struct IPort          *Port2;
  61.  
  62. void StartGame(void);
  63.  
  64. int main(void)
  65. {
  66.   void          *m68k_msg;
  67.   LONG          *cfg;
  68.   LONG          i;
  69.   struct MsgStartupData *msg_startup_data;
  70.  
  71.   if(__initstdio())
  72.   {
  73.   if(__initstdfio())
  74.   {
  75.  
  76.   msg_startup_data = (struct MsgStartupData *) PPCGetTaskAttr(PPCTASKTAG_STARTUP_MSGDATA);
  77.  
  78.   if((msg_startup_data->Version == VERNUM) && (msg_startup_data->Revision == REVNUM))
  79.   {
  80.     PPCPort = (void *) PPCGetTaskAttr(PPCTASKTAG_MSGPORT);
  81.   
  82.     if(PPCPort)
  83.     {
  84.       M68kPort = msg_startup_data->M68kPort;
  85.  
  86.       MyMsg = PPCCreateMessage(PPCPort, PPC_MSGSIZE_MAX);
  87.       
  88.       if(MyMsg)
  89.       {
  90.         MsgData = PPCAllocVec(PPC_MSGSIZE_MAX, MEMF_ANY);
  91.         
  92.         if(MsgData)
  93.         {
  94.           PPCCacheFlushAll();
  95.  
  96.           PPCSendMessage(M68kPort, MyMsg, &drivers, 0, PPC_MSG_READY);
  97.           PPCWaitPort(PPCPort);
  98.           PPCGetMessage(PPCPort);
  99.  
  100.           while(1)
  101.           {
  102.             PPCWaitPort(PPCPort);
  103.             m68k_msg = PPCGetMessage(PPCPort);
  104.  
  105.             cfg = (LONG *) PPCGetMessageAttr(m68k_msg, PPCMSGTAG_DATA);
  106.  
  107.             if(cfg)
  108.             {
  109.               PPCCacheFlushAll();
  110.  
  111.               for(i = 0; i < CFG_ITEMS; i++)
  112.                 Config[i] = cfg[M68k_MSGDATA_CONFIG + i];
  113.  
  114.               ChannelArray[0]   = (struct AChannelArray *) cfg[M68k_MSGDATA_CHANNELARRAY1];
  115.               ChannelArray[1]   = (struct AChannelArray *) cfg[M68k_MSGDATA_CHANNELARRAY2];
  116.               ChannelArraySize  = cfg[M68k_MSGDATA_CHANNELARRAYSIZE];
  117.  
  118.               PPCReplyMessage(m68k_msg);
  119.  
  120.               if(ChannelArray[0] && ChannelArray[1])
  121.               {
  122.                 PPCCacheInvalid(ChannelArray[0], ChannelArraySize);
  123.                 PPCCacheInvalid(ChannelArray[1], ChannelArraySize);
  124.               }
  125.             }
  126.             else
  127.             {           
  128.               PPCReplyMessage(m68k_msg);
  129.               break;
  130.             }
  131.             
  132.             Keys = NULL;
  133.  
  134.             StartGame();
  135.             
  136.             PPCSendMessage(M68kPort, MyMsg, 0, 0, PPC_MSG_QUIT);
  137.             PPCWaitPort(PPCPort);
  138.             PPCGetMessage(PPCPort);
  139.           }
  140.  
  141.           PPCFreeVec(MsgData);
  142.         }
  143.         PPCDeleteMessage(MyMsg);
  144.       }
  145.     }
  146.   }
  147.   }
  148.   __exitstdio();
  149.   }
  150.   __exitmalloc();
  151.  
  152.   return(0);
  153. }
  154.  
  155. LONG VideoOpen(LONG width, LONG height, LONG left, LONG top, LONG right, LONG bottom, LONG dirty)
  156. {
  157.   void  *m68k_msg;
  158.   LONG  *m68k_msg_data;
  159.  
  160.   MsgData[PPC_MSGDATA_WIDTH]  = width;
  161.   MsgData[PPC_MSGDATA_HEIGHT] = height;
  162.   MsgData[PPC_MSGDATA_LEFT]   = left;
  163.   MsgData[PPC_MSGDATA_TOP]    = top;
  164.   MsgData[PPC_MSGDATA_RIGHT]  = right;
  165.   MsgData[PPC_MSGDATA_BOTTOM] = bottom;
  166.   MsgData[PPC_MSGDATA_DIRTY]  = dirty;
  167.  
  168.   PPCSendMessage(M68kPort, MyMsg, MsgData, PPC_MSGSIZE_VIDEOOPEN, PPC_MSG_VIDEOOPEN);
  169.   PPCWaitPort(PPCPort);
  170.   PPCGetMessage(PPCPort);
  171.  
  172.   PPCWaitPort(PPCPort);
  173.   m68k_msg = PPCGetMessage(PPCPort);
  174.   
  175.   m68k_msg_data = (LONG *) PPCGetMessageAttr(m68k_msg, PPCMSGTAG_DATA);
  176.  
  177.   if(m68k_msg_data[M68k_MSGDATA_RESULT])
  178.   {
  179.     Width  = m68k_msg_data[M68k_MSGDATA_WIDTH];
  180.     Height = m68k_msg_data[M68k_MSGDATA_HEIGHT];
  181.  
  182.     PixelArray[0] = (struct VPixelArray *)  m68k_msg_data[M68k_MSGDATA_PIXELARRAY1];
  183.     PixelArray[1] = (struct VPixelArray *)  m68k_msg_data[M68k_MSGDATA_PIXELARRAY2];
  184.     DirectArray   = (struct VDirectArray *) m68k_msg_data[M68k_MSGDATA_DIRECTARRAY];
  185.  
  186.     Keys  = (UBYTE *)        m68k_msg_data[M68k_MSGDATA_KEYS];
  187.     Port1 = (struct IPort *) m68k_msg_data[M68k_MSGDATA_PORT1];
  188.     Port2 = (struct IPort *) m68k_msg_data[M68k_MSGDATA_PORT2];
  189.  
  190.     CurrentArray = 0;
  191.  
  192.     PPCReplyMessage(m68k_msg);
  193.  
  194.     PPCCacheFlushAll();
  195.  
  196.     return(1);
  197.   }
  198.  
  199.   PPCReplyMessage(m68k_msg);
  200.   
  201.   return(0);
  202. }
  203.  
  204. void VideoClose(void)
  205. {
  206.   PPCSendMessage(M68kPort, MyMsg, 0, 0, PPC_MSG_VIDEOCLOSE);
  207.   PPCWaitPort(PPCPort);
  208.   PPCGetMessage(PPCPort);
  209. }
  210.  
  211. void InputUpdate(LONG wait)
  212. {
  213.   if(wait)
  214.   {
  215.     PPCSendMessage(M68kPort, MyMsg, 0, 0, PPC_MSG_INPUTUPDATE);
  216.     PPCWaitPort(PPCPort);
  217.     PPCGetMessage(PPCPort);
  218.   }
  219. }
  220.  
  221. struct File *OpenFileType(const char *dir_name, const char *file_name, int mode, int type)
  222. {
  223.   struct File *file;
  224.   void    *m68k_msg;
  225.   LONG    i;
  226.  
  227.   i = 0;
  228.   if(dir_name)
  229.   {
  230.     for(; dir_name[i]; i++)
  231.       ((UBYTE *) &MsgData[PPC_MSGDATA_DIRNAME])[i] = dir_name[i];
  232.   }
  233.   ((UBYTE *) &MsgData[PPC_MSGDATA_DIRNAME])[i] = 0;
  234.  
  235.   i = 0;
  236.   if(file_name)
  237.   {
  238.     for(i = 0; file_name[i]; i++)
  239.       ((UBYTE *) &MsgData[PPC_MSGDATA_FILENAME])[i] = file_name[i];
  240.   }
  241.   ((UBYTE *) &MsgData[PPC_MSGDATA_FILENAME])[i] = 0;
  242.  
  243.   MsgData[PPC_MSGDATA_MODE] = mode;
  244.   MsgData[PPC_MSGDATA_TYPE] = type;
  245.  
  246.   PPCSendMessage(M68kPort, MyMsg, MsgData, PPC_MSGSIZE_OPENFILETYPE, PPC_MSG_OPENFILETYPE);
  247.   PPCWaitPort(PPCPort);
  248.   PPCGetMessage(PPCPort);
  249.  
  250.   PPCWaitPort(PPCPort);
  251.   m68k_msg = PPCGetMessage(PPCPort);
  252.   
  253.   file = (struct File *) PPCGetMessageAttr(m68k_msg, PPCMSGTAG_DATA);
  254.  
  255.   PPCReplyMessage(m68k_msg);
  256.  
  257.   return(file);
  258. }
  259.  
  260. void CloseFile(struct File *file)
  261. {
  262.   PPCSendMessage(M68kPort, MyMsg, file, 0, PPC_MSG_CLOSEFILE);
  263.   PPCWaitPort(PPCPort);
  264.   PPCGetMessage(PPCPort);
  265. }
  266.  
  267. void VSetPixelFrame(struct VPixelArray *pixelarray)
  268. {
  269.   void *m68k_msg;
  270.   LONG i;
  271.   
  272.   VFlushPixelArray(PixelArray[CurrentArray]);
  273.  
  274.   if(ChannelArray[0] && ChannelArray[1])
  275.     PPCCacheFlush(ChannelArray[CurrentArray], ChannelArraySize);
  276.  
  277.   PPCSendMessage(M68kPort, MyMsg, (void *) (CurrentArray|(frameskip<<4)|(throttle)<<8), 0, PPC_MSG_SETPIXELFRAME);
  278.   PPCWaitPort(PPCPort);
  279.   PPCGetMessage(PPCPort);
  280.  
  281.   PPCWaitPort(PPCPort);
  282.   m68k_msg  = PPCGetMessage(PPCPort); 
  283.   FrameSkip = (LONG) PPCGetMessageAttr(m68k_msg, PPCMSGTAG_DATA);
  284.   FPS       = FrameSkip & 0xffff;
  285.   FrameSkip = FrameSkip >> 16;
  286.   PPCReplyMessage(m68k_msg);
  287.  
  288.   if(Config[CFG_ASYNCPPC])
  289.   {
  290.     CurrentArray = (CurrentArray + 1) & 1;
  291.  
  292.     if(CurrentArray)
  293.       BitMap->line= (unsigned char **) ((ULONG) &BitMap[1] + BitMap->height * sizeof(unsigned char *));
  294.     else
  295.       BitMap->line= (unsigned char **) &BitMap[1];
  296.  
  297.     if(ClearBitMap)
  298.       osd_clearbitmap(BitMap);
  299.   }
  300.  
  301.   for(i = 0; i < 256; i++)
  302.     PixelArray[CurrentArray]->Palette[i][0] = 0;
  303.  
  304.   if(ChannelArray[0] && ChannelArray[1])
  305.   {
  306.     for(i = 0; i < AUDIO_CHANNELS; i++)
  307.       ChannelArray[CurrentArray]->Channels[i].Flags = 0;
  308.  
  309.     ChannelArray[CurrentArray]->Flags = 0;
  310.   }
  311. }
  312.  
  313. void VSetDirectFrame(struct VDirectArray *directarray)
  314. {
  315.   void  *m68k_msg;
  316.   LONG  i;
  317.   
  318.   if(ChannelArray[0] && ChannelArray[1])
  319.     PPCCacheFlush(ChannelArray[CurrentArray], ChannelArraySize);
  320.   PPCSendMessage(M68kPort, MyMsg, (void *) (CurrentArray|(frameskip<<4)|(throttle)<<8), 0, PPC_MSG_SETDIRECTFRAME);
  321.   PPCWaitPort(PPCPort);
  322.   PPCGetMessage(PPCPort);
  323.  
  324.   PPCWaitPort(PPCPort);
  325.   m68k_msg  = PPCGetMessage(PPCPort); 
  326.   FrameSkip = (LONG) PPCGetMessageAttr(m68k_msg, PPCMSGTAG_DATA);
  327.   FPS     = FrameSkip & 0xffff;
  328.   FrameSkip = FrameSkip >> 16;
  329.   PPCReplyMessage(m68k_msg);
  330.  
  331.   CurrentArray = (CurrentArray + 1) & 1;
  332.  
  333.   if(ChannelArray[0] && ChannelArray[1])
  334.   {
  335.     for(i = 0; i < AUDIO_CHANNELS; i++)
  336.       ChannelArray[CurrentArray]->Channels[i].Flags = 0;
  337.  
  338.     ChannelArray[CurrentArray]->Flags = 0;
  339.   }
  340. }
  341.  
  342. void ASetChannelFrame(struct AChannelArray *channelarray)
  343. {
  344. }
  345.  
  346. struct ASound *AReadSound(struct Audio *audio, BPTR file)
  347. {
  348.   struct ASound *sound;
  349.   void      *m68k_msg;
  350.  
  351.   PPCSendMessage(M68kPort, MyMsg, (void *) file, 0, PPC_MSG_READSOUND);
  352.   PPCWaitPort(PPCPort);
  353.   PPCGetMessage(PPCPort);
  354.  
  355.   PPCWaitPort(PPCPort);
  356.   m68k_msg = PPCGetMessage(PPCPort);
  357.  
  358.   sound = (struct ASound *) PPCGetMessageAttr(m68k_msg, PPCMSGTAG_DATA);
  359.  
  360.   PPCReplyMessage(m68k_msg);
  361.  
  362.   if(sound)
  363.     PPCCacheInvalid(sound, sizeof(struct ASound));
  364.  
  365.   return(sound);
  366. }
  367.  
  368.  
  369. struct ASound *ALoadSound(struct Audio *audio, UBYTE *sample, LONG res, LONG len, LONG freq, LONG vol)
  370. {
  371.   struct ASound *sound;
  372.   void      *m68k_msg;
  373.  
  374.   PPCCacheFlush(sample, len);
  375.  
  376.   MsgData[PPC_MSGDATA_SAMPLE]   = (LONG) sample;
  377.   MsgData[PPC_MSGDATA_RESOLUTION] = res;
  378.   MsgData[PPC_MSGDATA_LENGTH]   = len;
  379.   MsgData[PPC_MSGDATA_FREQUENCY]  = freq;
  380.   MsgData[PPC_MSGDATA_VOLUME]   = vol;
  381.  
  382.   PPCSendMessage(M68kPort, MyMsg, MsgData, PPC_MSGSIZE_LOADSOUND, PPC_MSG_LOADSOUND);
  383.   PPCWaitPort(PPCPort);
  384.   PPCGetMessage(PPCPort);
  385.  
  386.   PPCWaitPort(PPCPort);
  387.   m68k_msg = PPCGetMessage(PPCPort);
  388.  
  389.   sound = (struct ASound *) PPCGetMessageAttr(m68k_msg, PPCMSGTAG_DATA);
  390.  
  391.   PPCReplyMessage(m68k_msg);
  392.  
  393.   if(sound)
  394.     PPCCacheInvalid(sound, sizeof(struct ASound));
  395.  
  396.   return(sound);
  397. }
  398.